home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / nss / pk11pub.h < prev    next >
C/C++ Source or Header  |  2006-04-20  |  35KB  |  701 lines
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  3.  *
  4.  * The contents of this file are subject to the Mozilla Public License Version
  5.  * 1.1 (the "License"); you may not use this file except in compliance with
  6.  * the License. You may obtain a copy of the License at
  7.  * http://www.mozilla.org/MPL/
  8.  *
  9.  * Software distributed under the License is distributed on an "AS IS" basis,
  10.  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11.  * for the specific language governing rights and limitations under the
  12.  * License.
  13.  *
  14.  * The Original Code is the Netscape security libraries.
  15.  *
  16.  * The Initial Developer of the Original Code is
  17.  * Netscape Communications Corporation.
  18.  * Portions created by the Initial Developer are Copyright (C) 1994-2000
  19.  * the Initial Developer. All Rights Reserved.
  20.  *
  21.  * Contributor(s):
  22.  *   Douglas Stebila <douglas@stebila.ca>, Sun Microsystems Laboratories
  23.  *
  24.  * Alternatively, the contents of this file may be used under the terms of
  25.  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26.  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27.  * in which case the provisions of the GPL or the LGPL are applicable instead
  28.  * of those above. If you wish to allow use of your version of this file only
  29.  * under the terms of either the GPL or the LGPL, and not to allow others to
  30.  * use your version of this file under the terms of the MPL, indicate your
  31.  * decision by deleting the provisions above and replace them with the notice
  32.  * and other provisions required by the GPL or the LGPL. If you do not delete
  33.  * the provisions above, a recipient may use your version of this file under
  34.  * the terms of any one of the MPL, the GPL or the LGPL.
  35.  *
  36.  * ***** END LICENSE BLOCK ***** */
  37. #ifndef _PK11PUB_H_
  38. #define _PK11PUB_H_
  39. #include "plarena.h"
  40. #include "seccomon.h"
  41. #include "secoidt.h"
  42. #include "secdert.h"
  43. #include "keyt.h"
  44. #include "certt.h"
  45. #include "pkcs11t.h"
  46. #include "secmodt.h"
  47. #include "seccomon.h"
  48. #include "pkcs7t.h"
  49. #include "cmsreclist.h"
  50.  
  51. /*
  52.  * Exported PK11 wrap functions.
  53.  */
  54.  
  55. SEC_BEGIN_PROTOS
  56.  
  57. /************************************************************
  58.  * Generic Slot Lists Management
  59.  ************************************************************/
  60. void PK11_FreeSlotList(PK11SlotList *list);
  61. SECStatus PK11_FreeSlotListElement(PK11SlotList *list, PK11SlotListElement *le);
  62. PK11SlotListElement * PK11_GetFirstSafe(PK11SlotList *list);
  63. PK11SlotListElement *PK11_GetNextSafe(PK11SlotList *list, 
  64.                 PK11SlotListElement *le, PRBool restart);
  65.  
  66. /************************************************************
  67.  * Generic Slot Management
  68.  ************************************************************/
  69. PK11SlotInfo *PK11_ReferenceSlot(PK11SlotInfo *slot);
  70. void PK11_FreeSlot(PK11SlotInfo *slot);
  71. SECStatus PK11_DestroyObject(PK11SlotInfo *slot,CK_OBJECT_HANDLE object);
  72. SECStatus PK11_DestroyTokenObject(PK11SlotInfo *slot,CK_OBJECT_HANDLE object);
  73. PK11SlotInfo *PK11_GetInternalKeySlot(void);
  74. PK11SlotInfo *PK11_GetInternalSlot(void);
  75. SECStatus PK11_Logout(PK11SlotInfo *slot);
  76. void PK11_LogoutAll(void);
  77.  
  78.  
  79. /************************************************************
  80.  *  Slot Password Management
  81.  ************************************************************/
  82. void PK11_SetSlotPWValues(PK11SlotInfo *slot,int askpw, int timeout);
  83. void PK11_GetSlotPWValues(PK11SlotInfo *slot,int *askpw, int *timeout);
  84. SECStatus PK11_CheckSSOPassword(PK11SlotInfo *slot, char *ssopw);
  85. SECStatus PK11_CheckUserPassword(PK11SlotInfo *slot,char *pw);
  86. PRBool PK11_IsLoggedIn(PK11SlotInfo *slot, void *wincx);
  87. SECStatus PK11_InitPin(PK11SlotInfo *slot,char *ssopw, char *pk11_userpwd);
  88. SECStatus PK11_ChangePW(PK11SlotInfo *slot,char *oldpw, char *newpw);
  89. void PK11_SetPasswordFunc(PK11PasswordFunc func);
  90. int PK11_GetMinimumPwdLength(PK11SlotInfo *slot);
  91. SECStatus PK11_ResetToken(PK11SlotInfo *slot, char *sso_pwd);
  92. SECStatus PK11_Authenticate(PK11SlotInfo *slot, PRBool loadCerts, void *wincx);
  93. SECStatus PK11_TokenRefresh(PK11SlotInfo *slot);
  94.  
  95.  
  96. /******************************************************************
  97.  *           Slot info functions
  98.  ******************************************************************/
  99. PK11SlotInfo *PK11_FindSlotByName(const char *name);
  100. /******************************************************************
  101.  * PK11_FindSlotsByNames searches for a PK11SlotInfo using one or
  102.  * more criteria : dllName, slotName and tokenName . In addition, if
  103.  * presentOnly is set , only slots with a token inserted will be
  104.  * returned.
  105.  ******************************************************************/
  106. PK11SlotList *PK11_FindSlotsByNames(const char *dllName,
  107.         const char* slotName, const char* tokenName, PRBool presentOnly);
  108. PRBool PK11_IsReadOnly(PK11SlotInfo *slot);
  109. PRBool PK11_IsInternal(PK11SlotInfo *slot);
  110. char * PK11_GetTokenName(PK11SlotInfo *slot);
  111. char * PK11_GetSlotName(PK11SlotInfo *slot);
  112. PRBool PK11_NeedLogin(PK11SlotInfo *slot);
  113. PRBool PK11_IsFriendly(PK11SlotInfo *slot);
  114. PRBool PK11_IsHW(PK11SlotInfo *slot);
  115. PRBool PK11_NeedUserInit(PK11SlotInfo *slot);
  116. PRBool PK11_ProtectedAuthenticationPath(PK11SlotInfo *slot);
  117. int PK11_GetSlotSeries(PK11SlotInfo *slot);
  118. int PK11_GetCurrentWrapIndex(PK11SlotInfo *slot);
  119. unsigned long PK11_GetDefaultFlags(PK11SlotInfo *slot);
  120. CK_SLOT_ID PK11_GetSlotID(PK11SlotInfo *slot);
  121. SECMODModuleID PK11_GetModuleID(PK11SlotInfo *slot);
  122. SECStatus PK11_GetSlotInfo(PK11SlotInfo *slot, CK_SLOT_INFO *info);
  123. SECStatus PK11_GetTokenInfo(PK11SlotInfo *slot, CK_TOKEN_INFO *info);
  124. PRBool PK11_IsDisabled(PK11SlotInfo *slot);
  125. PRBool PK11_HasRootCerts(PK11SlotInfo *slot);
  126. PK11DisableReasons PK11_GetDisabledReason(PK11SlotInfo *slot);
  127. /* Prevents the slot from being used, and set disable reason to user-disable */
  128. /* NOTE: Mechanisms that were ON continue to stay ON */
  129. /*       Therefore, when the slot is enabled, it will remember */
  130. /*       what mechanisms needs to be turned on */
  131. PRBool PK11_UserDisableSlot(PK11SlotInfo *slot);
  132. /* Allow all mechanisms that are ON before UserDisableSlot() */
  133. /* was called to be available again */
  134. PRBool PK11_UserEnableSlot(PK11SlotInfo *slot);
  135. /*
  136.  * wait for a specific slot event.
  137.  * event is a specific event to wait for. Currently only 
  138.  *    PK11TokenChangeOrRemovalEvent and PK11TokenPresentEvents are defined.
  139.  * timeout can be an interval time to wait, PR_INTERVAL_NO_WAIT (meaning only
  140.  * poll once), or PR_INTERVAL_NO_TIMEOUT (meaning block until a change).
  141.  * pollInterval is a suggested pulling interval value. '0' means use the 
  142.  *  default. Future implementations that don't poll may ignore this value.
  143.  * series is the current series for the last slot. This should be the series 
  144.  *  value for the slot the last time you read persistant information from the
  145.  *  slot. For instance, if you publish a cert from the slot, you should obtain
  146.  *  the slot series at that time. Then PK11_WaitForTokenEvent can detect a 
  147.  *  a change in the slot between the time you publish and the time 
  148.  *  PK11_WaitForTokenEvent is called, elliminating potential race conditions.
  149.  *
  150.  * The current status that is returned is:
  151.  *   PK11TokenNotRemovable - always returned for any non-removable token.
  152.  *   PK11TokenPresent - returned when the token is present and we are waiting
  153.  *     on a PK11TokenPresentEvent. Then next event to look for is a 
  154.  *     PK11TokenChangeOrRemovalEvent.
  155.  *   PK11TokenChanged - returned when the old token has been removed and a new
  156.  *     token ad been inserted, and we are waiting for a 
  157.  *     PK11TokenChangeOrRemovalEvent. The next event to look for is another
  158.  *     PK11TokenChangeOrRemovalEvent.
  159.  *   PK11TokenRemoved - returned when the token is not present and we are 
  160.  *     waiting for a PK11TokenChangeOrRemovalEvent. The next event to look for 
  161.  *     is a PK11TokenPresentEvent.
  162.  */
  163. PK11TokenStatus PK11_WaitForTokenEvent(PK11SlotInfo *slot, PK11TokenEvent event,
  164.     PRIntervalTime timeout, PRIntervalTime pollInterval, int series);
  165.  
  166. PRBool PK11_NeedPWInit(void);
  167. PRBool PK11_TokenExists(CK_MECHANISM_TYPE);
  168. SECStatus PK11_GetModInfo(SECMODModule *mod, CK_INFO *info);
  169. PRBool PK11_IsFIPS(void);
  170. SECMODModule *PK11_GetModule(PK11SlotInfo *slot);
  171.  
  172. /*********************************************************************
  173.  *            Slot mapping utility functions.
  174.  *********************************************************************/
  175. PRBool PK11_IsPresent(PK11SlotInfo *slot);
  176. PRBool PK11_DoesMechanism(PK11SlotInfo *slot, CK_MECHANISM_TYPE type);
  177. PK11SlotList * PK11_GetAllTokens(CK_MECHANISM_TYPE type,PRBool needRW,
  178.                     PRBool loadCerts, void *wincx);
  179. PK11SlotInfo *PK11_GetBestSlotMultiple(CK_MECHANISM_TYPE *type, int count,
  180.                             void *wincx);
  181. PK11SlotInfo *PK11_GetBestSlot(CK_MECHANISM_TYPE type, void *wincx);
  182. CK_MECHANISM_TYPE PK11_GetBestWrapMechanism(PK11SlotInfo *slot);
  183. int PK11_GetBestKeyLength(PK11SlotInfo *slot, CK_MECHANISM_TYPE type);
  184. /*
  185.  * Open a new database using the softoken. The caller is responsible for making
  186.  * sure the module spec is correct and usable. The caller should ask for one
  187.  * new database per call if the caller wants to get meaningful information
  188.  * about the new database.
  189.  *
  190.  * moduleSpec is the same data that you would pass to softoken at
  191.  * initialization time under the 'tokens' options. For example, if you were
  192.  * to specify tokens=<0x4=[configdir='./mybackup' tokenDescription='Backup']>
  193.  * You would specify "configdir='./mybackup' tokenDescription='Backup'" as your
  194.  * module spec here. The slot ID will be calculated for you by
  195.  * SECMOD_OpenUserDB().
  196.  *
  197.  * Typical parameters here are configdir, tokenDescription and flags.
  198.  *
  199.  * a Full list is below:
  200.  *
  201.  *
  202.  *  configDir - The location of the databases for this token. If configDir is
  203.  *         not specified, and noCertDB and noKeyDB is not specified, the load
  204.  *         will fail.
  205.  *   certPrefix - Cert prefix for this token.
  206.  *   keyPrefix - Prefix for the key database for this token. (if not specified,
  207.  *         certPrefix will be used).
  208.  *   tokenDescription - The label value for this token returned in the
  209.  *         CK_TOKEN_INFO structure with an internationalize string (UTF8).
  210.  *         This value will be truncated at 32 bytes (no NULL, partial UTF8
  211.  *         characters dropped). You should specify a user friendly name here
  212.  *         as this is the value the token will be refered to in most
  213.  *         application UI's. You should make sure tokenDescription is unique.
  214.  *   slotDescription - The slotDescription value for this token returned
  215.  *         in the CK_SLOT_INFO structure with an internationalize string
  216.  *         (UTF8). This value will be truncated at 64 bytes (no NULL, partial
  217.  *         UTF8 characters dropped). This name will not change after the
  218.  *         database is closed. It should have some number to make this unique.
  219.  *   minPWLen - minimum password length for this token.
  220.  *   flags - comma separated list of flag values, parsed case-insensitive.
  221.  *         Valid flags are:
  222.  *              readOnly - Databases should be opened read only.
  223.  *              noCertDB - Don't try to open a certificate database.
  224.  *              noKeyDB - Don't try to open a key database.
  225.  *              forceOpen - Don't fail to initialize the token if the
  226.  *                databases could not be opened.
  227.  *              passwordRequired - zero length passwords are not acceptable
  228.  *                (valid only if there is a keyDB).
  229.  *              optimizeSpace - allocate smaller hash tables and lock tables.
  230.  *                When this flag is not specified, Softoken will allocate
  231.  *                large tables to prevent lock contention.
  232.  */
  233. PK11SlotInfo *SECMOD_OpenUserDB(const char *moduleSpec);
  234. SECStatus SECMOD_CloseUserDB(PK11SlotInfo *slot);
  235.  
  236. /*********************************************************************
  237.  *       Mechanism Mapping functions
  238.  *********************************************************************/
  239. CK_MECHANISM_TYPE PK11_GetKeyType(CK_MECHANISM_TYPE type,unsigned long len);
  240. CK_MECHANISM_TYPE PK11_GetKeyGen(CK_MECHANISM_TYPE type);
  241. int PK11_GetBlockSize(CK_MECHANISM_TYPE type,SECItem *params);
  242. int PK11_GetIVLength(CK_MECHANISM_TYPE type);
  243. SECItem *PK11_ParamFromIV(CK_MECHANISM_TYPE type,SECItem *iv);
  244. unsigned char *PK11_IVFromParam(CK_MECHANISM_TYPE type,SECItem *param,int *len);
  245. SECItem * PK11_BlockData(SECItem *data,unsigned long size);
  246.  
  247. /* PKCS #11 to DER mapping functions */
  248. SECItem *PK11_ParamFromAlgid(SECAlgorithmID *algid);
  249. SECItem *PK11_GenerateNewParam(CK_MECHANISM_TYPE, PK11SymKey *);
  250. CK_MECHANISM_TYPE PK11_AlgtagToMechanism(SECOidTag algTag);
  251. SECOidTag PK11_MechanismToAlgtag(CK_MECHANISM_TYPE type);
  252. SECOidTag PK11_FortezzaMapSig(SECOidTag algTag);
  253. SECStatus PK11_ParamToAlgid(SECOidTag algtag, SECItem *param,
  254.                                    PRArenaPool *arena, SECAlgorithmID *algid);
  255. SECStatus PK11_SeedRandom(PK11SlotInfo *,unsigned char *data,int len);
  256. SECStatus PK11_GenerateRandomOnSlot(PK11SlotInfo *,unsigned char *data,int len);
  257. SECStatus PK11_RandomUpdate(void *data, size_t bytes);
  258. SECStatus PK11_GenerateRandom(unsigned char *data,int len);
  259. CK_RV PK11_MapPBEMechanismToCryptoMechanism(CK_MECHANISM_PTR pPBEMechanism,
  260.                         CK_MECHANISM_PTR pCryptoMechanism,
  261.                         SECItem *pbe_pwd, PRBool bad3DES);
  262. CK_MECHANISM_TYPE PK11_GetPadMechanism(CK_MECHANISM_TYPE);
  263. CK_MECHANISM_TYPE PK11_MapSignKeyType(KeyType keyType);
  264.  
  265. /**********************************************************************
  266.  *                   Symetric, Public, and Private Keys 
  267.  **********************************************************************/
  268. void PK11_FreeSymKey(PK11SymKey *key);
  269. PK11SymKey *PK11_ReferenceSymKey(PK11SymKey *symKey);
  270. PK11SymKey *PK11_ImportSymKey(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
  271.     PK11Origin origin, CK_ATTRIBUTE_TYPE operation, SECItem *key, void *wincx);
  272. PK11SymKey *PK11_ImportSymKeyWithFlags(PK11SlotInfo *slot, 
  273.     CK_MECHANISM_TYPE type, PK11Origin origin, CK_ATTRIBUTE_TYPE operation, 
  274.     SECItem *key, CK_FLAGS flags, PRBool isPerm, void *wincx);
  275. PK11SymKey *PK11_SymKeyFromHandle(PK11SlotInfo *slot, PK11SymKey *parent,
  276.     PK11Origin origin, CK_MECHANISM_TYPE type, CK_OBJECT_HANDLE keyID, 
  277.     PRBool owner, void *wincx);
  278. PK11SymKey *PK11_GetWrapKey(PK11SlotInfo *slot, int wrap,
  279.                   CK_MECHANISM_TYPE type,int series, void *wincx);
  280. /*
  281.  * This function is not thread-safe.  It can only be called when only
  282.  * one thread has a reference to wrapKey.
  283.  */
  284. void PK11_SetWrapKey(PK11SlotInfo *slot, int wrap, PK11SymKey *wrapKey);
  285. CK_MECHANISM_TYPE PK11_GetMechanism(PK11SymKey *symKey);
  286. CK_OBJECT_HANDLE PK11_ImportPublicKey(PK11SlotInfo *slot, 
  287.                 SECKEYPublicKey *pubKey, PRBool isToken);
  288. PK11SymKey *PK11_KeyGen(PK11SlotInfo *slot,CK_MECHANISM_TYPE type,
  289.                 SECItem *param,    int keySize,void *wincx);
  290. PK11SymKey *PK11_TokenKeyGen(PK11SlotInfo *slot, CK_MECHANISM_TYPE type,
  291.                 SECItem *param, int keySize, SECItem *keyid,
  292.                 PRBool isToken, void *wincx);
  293. PK11SymKey *PK11_TokenKeyGenWithFlags(PK11SlotInfo *slot,
  294.                 CK_MECHANISM_TYPE type, SECItem *param,
  295.                 int keySize, SECItem *keyid, CK_FLAGS opFlags,
  296.                 PK11AttrFlags attrFlags, void *wincx);
  297. PK11SymKey * PK11_ListFixedKeysInSlot(PK11SlotInfo *slot, char *nickname,
  298.                                 void *wincx);
  299. PK11SymKey *PK11_GetNextSymKey(PK11SymKey *symKey);
  300. CK_KEY_TYPE PK11_GetSymKeyType(PK11SymKey *key);
  301.  
  302. /*
  303.  * PK11_SetSymKeyUserData
  304.  *   sets generic user data on keys (usually a pointer to a data structure)
  305.  * that can later be retrieved by PK11_GetSymKeyUserData().
  306.  *    symKey - key where data will be set.
  307.  *    data - data to be set.
  308.  *    freefunc - function used to free the data.
  309.  * Setting user data on symKeys with existing user data already set will cause 
  310.  * the existing user data to be freed before the new user data is set.
  311.  * Freeing user data is done by calling the user specified freefunc. 
  312.  * If freefunc is NULL, the user data is assumed to be global or static an 
  313.  * not freed. Passing NULL for user data to PK11_SetSymKeyUserData has the 
  314.  * effect of freeing any existing user data, and clearing the user data 
  315.  * pointer. If user data exists when the symKey is finally freed, that 
  316.  * data will be freed with freefunc.
  317.  *
  318.  * Applications should only use this function on keys which the application
  319.  * has created directly, as there is only one user data value per key.
  320.  */
  321. void PK11_SetSymKeyUserData(PK11SymKey *symKey, void *data, 
  322.                                  PK11FreeDataFunc freefunc);
  323. /* PK11_GetSymKeyUserData 
  324.  *   retrieves generic user data which was set on a key by 
  325.  * PK11_SetSymKeyUserData.
  326.  *    symKey - key with data to be fetched
  327.  *
  328.  * If no data exists, or the data has been cleared, PK11_GetSymKeyUserData
  329.  * will return NULL. Returned data is still owned and managed by the SymKey,
  330.  * the caller should not free the data.
  331.  *
  332.  */
  333. void *PK11_GetSymKeyUserData(PK11SymKey *symKey);
  334.  
  335. SECStatus PK11_PubWrapSymKey(CK_MECHANISM_TYPE type, SECKEYPublicKey *pubKey,
  336.                 PK11SymKey *symKey, SECItem *wrappedKey);
  337. SECStatus PK11_WrapSymKey(CK_MECHANISM_TYPE type, SECItem *params,
  338.      PK11SymKey *wrappingKey, PK11SymKey *symKey, SECItem *wrappedKey);
  339. /* move a key to 'slot' optionally set the key attributes according to either
  340.  * operation or the  flags and making the key permanent at the same time.
  341.  * If the key is moved to the same slot, operation and flags values are 
  342.  * currently ignored */
  343. PK11SymKey *PK11_MoveSymKey(PK11SlotInfo *slot, CK_ATTRIBUTE_TYPE operation, 
  344.             CK_FLAGS flags, PRBool  perm, PK11SymKey *symKey);
  345. /*
  346.  * derive a new key from the base key.
  347.  *  PK11_Derive returns a key which can do exactly one operation, and is
  348.  * ephemeral (session key).
  349.  *  PK11_DeriveWithFlags is the same as PK11_Derive, except you can use
  350.  * CKF_ flags to enable more than one operation.
  351.  *  PK11_DeriveWithFlagsPerm is the same as PK11_DeriveWithFlags except you can
  352.  *  (optionally) make the key permanent (token key).
  353.  */
  354. PK11SymKey *PK11_Derive(PK11SymKey *baseKey, CK_MECHANISM_TYPE mechanism,
  355.                SECItem *param, CK_MECHANISM_TYPE target, 
  356.                 CK_ATTRIBUTE_TYPE operation, int keySize);
  357. PK11SymKey *PK11_DeriveWithFlags( PK11SymKey *baseKey, 
  358.     CK_MECHANISM_TYPE derive, SECItem *param, CK_MECHANISM_TYPE target, 
  359.     CK_ATTRIBUTE_TYPE operation, int keySize, CK_FLAGS flags);
  360. PK11SymKey * PK11_DeriveWithFlagsPerm( PK11SymKey *baseKey, 
  361.     CK_MECHANISM_TYPE derive, 
  362.     SECItem *param, CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation, 
  363.     int keySize, CK_FLAGS flags, PRBool isPerm);
  364.  
  365. PK11SymKey *PK11_PubDerive( SECKEYPrivateKey *privKey, 
  366.  SECKEYPublicKey *pubKey, PRBool isSender, SECItem *randomA, SECItem *randomB,
  367.  CK_MECHANISM_TYPE derive, CK_MECHANISM_TYPE target,
  368.          CK_ATTRIBUTE_TYPE operation, int keySize,void *wincx) ;
  369. PK11SymKey *PK11_PubDeriveWithKDF( SECKEYPrivateKey *privKey, 
  370.  SECKEYPublicKey *pubKey, PRBool isSender, SECItem *randomA, SECItem *randomB,
  371.  CK_MECHANISM_TYPE derive, CK_MECHANISM_TYPE target,
  372.          CK_ATTRIBUTE_TYPE operation, int keySize,
  373.          CK_ULONG kdf, SECItem *sharedData, void *wincx);
  374.  
  375. /*
  376.  * unwrap a new key with a symetric key.
  377.  *  PK11_Unwrap returns a key which can do exactly one operation, and is
  378.  * ephemeral (session key).
  379.  *  PK11_UnwrapWithFlags is the same as PK11_Unwrap, except you can use
  380.  * CKF_ flags to enable more than one operation.
  381.  *  PK11_UnwrapWithFlagsPerm is the same as PK11_UnwrapWithFlags except you can
  382.  *  (optionally) make the key permanent (token key).
  383.  */
  384. PK11SymKey *PK11_UnwrapSymKey(PK11SymKey *key, 
  385.     CK_MECHANISM_TYPE wraptype, SECItem *param, SECItem *wrapppedKey,  
  386.     CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation, int keySize);
  387. PK11SymKey *PK11_UnwrapSymKeyWithFlags(PK11SymKey *wrappingKey, 
  388.     CK_MECHANISM_TYPE wrapType, SECItem *param, SECItem *wrappedKey, 
  389.     CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation, int keySize, 
  390.     CK_FLAGS flags);
  391. PK11SymKey * PK11_UnwrapSymKeyWithFlagsPerm(PK11SymKey *wrappingKey, 
  392.     CK_MECHANISM_TYPE wrapType,
  393.         SECItem *param, SECItem *wrappedKey, 
  394.     CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation, 
  395.      int keySize, CK_FLAGS flags, PRBool isPerm);
  396.  
  397. /*
  398.  * unwrap a new key with a private key.
  399.  *  PK11_PubUnwrap returns a key which can do exactly one operation, and is
  400.  * ephemeral (session key).
  401.  *  PK11_PubUnwrapWithFlagsPerm is the same as PK11_PubUnwrap except you can 
  402.  * use * CKF_ flags to enable more than one operation, and optionally make 
  403.  * the key permanent (token key).
  404.  */
  405. PK11SymKey *PK11_PubUnwrapSymKey(SECKEYPrivateKey *key, SECItem *wrapppedKey,
  406.      CK_MECHANISM_TYPE target, CK_ATTRIBUTE_TYPE operation, int keySize);
  407. PK11SymKey * PK11_PubUnwrapSymKeyWithFlagsPerm(SECKEYPrivateKey *wrappingKey, 
  408.       SECItem *wrappedKey, CK_MECHANISM_TYPE target, 
  409.       CK_ATTRIBUTE_TYPE operation, int keySize,
  410.       CK_FLAGS flags, PRBool isPerm);
  411. PK11SymKey *PK11_FindFixedKey(PK11SlotInfo *slot, CK_MECHANISM_TYPE type, 
  412.                         SECItem *keyID, void *wincx);
  413. SECStatus PK11_DeleteTokenPrivateKey(SECKEYPrivateKey *privKey,PRBool force);
  414. SECStatus PK11_DeleteTokenPublicKey(SECKEYPublicKey *pubKey);
  415. SECStatus PK11_DeleteTokenSymKey(PK11SymKey *symKey);
  416. SECStatus PK11_DeleteTokenCertAndKey(CERTCertificate *cert,void *wincx);
  417. SECKEYPrivateKey * PK11_LoadPrivKey(PK11SlotInfo *slot,
  418.         SECKEYPrivateKey *privKey, SECKEYPublicKey *pubKey, 
  419.                     PRBool token, PRBool sensitive);
  420. char * PK11_GetSymKeyNickname(PK11SymKey *symKey);
  421. char * PK11_GetPrivateKeyNickname(SECKEYPrivateKey *privKey);
  422. char * PK11_GetPublicKeyNickname(SECKEYPublicKey *pubKey);
  423. SECStatus PK11_SetSymKeyNickname(PK11SymKey *symKey, const char *nickname);
  424. SECStatus PK11_SetPrivateKeyNickname(SECKEYPrivateKey *privKey, 
  425.                             const char *nickname);
  426. SECStatus PK11_SetPublicKeyNickname(SECKEYPublicKey *pubKey, 
  427.                             const char *nickname);
  428.  
  429. /* size to hold key in bytes */
  430. unsigned int PK11_GetKeyLength(PK11SymKey *key);
  431. /* size of actual secret parts of key in bits */
  432. /* algid is because RC4 strength is determined by the effective bits as well
  433.  * as the key bits */
  434. unsigned int PK11_GetKeyStrength(PK11SymKey *key,SECAlgorithmID *algid);
  435. SECStatus PK11_ExtractKeyValue(PK11SymKey *symKey);
  436. SECItem * PK11_GetKeyData(PK11SymKey *symKey);
  437. PK11SlotInfo * PK11_GetSlotFromKey(PK11SymKey *symKey);
  438. void *PK11_GetWindow(PK11SymKey *symKey);
  439. /*
  440.  * The attrFlags is the logical OR of the PK11_ATTR_XXX bitflags.
  441.  * These flags apply to the private key.  The PK11_ATTR_TOKEN,
  442.  * PK11_ATTR_SESSION, PK11_ATTR_MODIFIABLE, and PK11_ATTR_UNMODIFIABLE
  443.  * flags also apply to the public key.
  444.  */
  445. SECKEYPrivateKey *PK11_GenerateKeyPairWithFlags(PK11SlotInfo *slot,
  446.    CK_MECHANISM_TYPE type, void *param, SECKEYPublicKey **pubk,
  447.                  PK11AttrFlags attrFlags, void *wincx);
  448. SECKEYPrivateKey *PK11_GenerateKeyPair(PK11SlotInfo *slot,
  449.    CK_MECHANISM_TYPE type, void *param, SECKEYPublicKey **pubk,
  450.                  PRBool isPerm, PRBool isSensitive, void *wincx);
  451. SECKEYPrivateKey * PK11_FindPrivateKeyFromCert(PK11SlotInfo *slot,
  452.                      CERTCertificate *cert, void *wincx);
  453. SECKEYPrivateKey * PK11_FindKeyByAnyCert(CERTCertificate *cert, void *wincx);
  454. SECKEYPrivateKey * PK11_FindKeyByKeyID(PK11SlotInfo *slot, SECItem *keyID,
  455.                        void *wincx);
  456. int PK11_GetPrivateModulusLen(SECKEYPrivateKey *key); 
  457.  
  458. /* note: despite the name, this function takes a private key. */
  459. SECStatus PK11_PubDecryptRaw(SECKEYPrivateKey *key, unsigned char *data,
  460.    unsigned *outLen, unsigned int maxLen, unsigned char *enc, unsigned encLen);
  461. #define PK11_PrivDecryptRaw PK11_PubDecryptRaw
  462. /* The encrypt function that complements the above decrypt function. */
  463. SECStatus PK11_PubEncryptRaw(SECKEYPublicKey *key, unsigned char *enc,
  464.                 unsigned char *data, unsigned dataLen, void *wincx);
  465.  
  466. SECStatus PK11_PrivDecryptPKCS1(SECKEYPrivateKey *key, unsigned char *data,
  467.    unsigned *outLen, unsigned int maxLen, unsigned char *enc, unsigned encLen);
  468. /* The encrypt function that complements the above decrypt function. */
  469. SECStatus PK11_PubEncryptPKCS1(SECKEYPublicKey *key, unsigned char *enc,
  470.                 unsigned char *data, unsigned dataLen, void *wincx);
  471.  
  472. SECStatus PK11_ImportPrivateKeyInfo(PK11SlotInfo *slot, 
  473.         SECKEYPrivateKeyInfo *pki, SECItem *nickname,
  474.         SECItem *publicValue, PRBool isPerm, PRBool isPrivate,
  475.         unsigned int usage, void *wincx);
  476. SECStatus PK11_ImportPrivateKeyInfoAndReturnKey(PK11SlotInfo *slot, 
  477.         SECKEYPrivateKeyInfo *pki, SECItem *nickname,
  478.         SECItem *publicValue, PRBool isPerm, PRBool isPrivate,
  479.         unsigned int usage, SECKEYPrivateKey** privk, void *wincx);
  480. SECStatus PK11_ImportDERPrivateKeyInfo(PK11SlotInfo *slot, 
  481.         SECItem *derPKI, SECItem *nickname,
  482.         SECItem *publicValue, PRBool isPerm, PRBool isPrivate,
  483.         unsigned int usage, void *wincx);
  484. SECStatus PK11_ImportDERPrivateKeyInfoAndReturnKey(PK11SlotInfo *slot, 
  485.         SECItem *derPKI, SECItem *nickname,
  486.         SECItem *publicValue, PRBool isPerm, PRBool isPrivate,
  487.         unsigned int usage, SECKEYPrivateKey** privk, void *wincx);
  488. SECStatus PK11_ImportEncryptedPrivateKeyInfo(PK11SlotInfo *slot, 
  489.         SECKEYEncryptedPrivateKeyInfo *epki, SECItem *pwitem, 
  490.         SECItem *nickname, SECItem *publicValue, PRBool isPerm,
  491.         PRBool isPrivate, KeyType type, 
  492.         unsigned int usage, void *wincx);
  493. SECKEYPrivateKeyInfo *PK11_ExportPrivateKeyInfo(
  494.         CERTCertificate *cert, void *wincx);
  495. SECKEYEncryptedPrivateKeyInfo *PK11_ExportEncryptedPrivKeyInfo(
  496.         PK11SlotInfo *slot, SECOidTag algTag, SECItem *pwitem,
  497.         SECKEYPrivateKey *pk, int iteration, void *wincx);
  498. SECKEYEncryptedPrivateKeyInfo *PK11_ExportEncryptedPrivateKeyInfo(
  499.         PK11SlotInfo *slot, SECOidTag algTag, SECItem *pwitem,
  500.         CERTCertificate *cert, int iteration, void *wincx);
  501. SECKEYPrivateKey *PK11_FindKeyByDERCert(PK11SlotInfo *slot, 
  502.                     CERTCertificate *cert, void *wincx);
  503. SECKEYPublicKey *PK11_MakeKEAPubKey(unsigned char *data, int length);
  504. SECStatus PK11_DigestKey(PK11Context *context, PK11SymKey *key);
  505. PRBool PK11_VerifyKeyOK(PK11SymKey *key);
  506. SECKEYPrivateKey *PK11_UnwrapPrivKey(PK11SlotInfo *slot, 
  507.         PK11SymKey *wrappingKey, CK_MECHANISM_TYPE wrapType,
  508.         SECItem *param, SECItem *wrappedKey, SECItem *label, 
  509.         SECItem *publicValue, PRBool token, PRBool sensitive,
  510.         CK_KEY_TYPE keyType, CK_ATTRIBUTE_TYPE *usage, int usageCount,
  511.         void *wincx);
  512. SECStatus PK11_WrapPrivKey(PK11SlotInfo *slot, PK11SymKey *wrappingKey,
  513.                SECKEYPrivateKey *privKey, CK_MECHANISM_TYPE wrapType,
  514.                SECItem *param, SECItem *wrappedKey, void *wincx);
  515. SECItem* PK11_DEREncodePublicKey(SECKEYPublicKey *pubk);
  516. PK11SymKey* PK11_CopySymKeyForSigning(PK11SymKey *originalKey,
  517.     CK_MECHANISM_TYPE mech);
  518. SECKEYPrivateKeyList* PK11_ListPrivKeysInSlot(PK11SlotInfo *slot,
  519.                          char *nickname, void *wincx);
  520. SECKEYPublicKeyList* PK11_ListPublicKeysInSlot(PK11SlotInfo *slot,
  521.                             char *nickname);
  522. SECKEYPQGParams *PK11_GetPQGParamsFromPrivateKey(SECKEYPrivateKey *privKey);
  523. /* depricated */
  524. SECKEYPrivateKeyList* PK11_ListPrivateKeysInSlot(PK11SlotInfo *slot);
  525.  
  526. PK11SymKey *PK11_ConvertSessionSymKeyToTokenSymKey(PK11SymKey *symk,
  527.     void *wincx);
  528. SECKEYPrivateKey *PK11_ConvertSessionPrivKeyToTokenPrivKey(
  529.     SECKEYPrivateKey *privk, void* wincx);
  530. SECKEYPrivateKey * PK11_CopyTokenPrivKeyToSessionPrivKey(PK11SlotInfo *destSlot,
  531.                       SECKEYPrivateKey *privKey);
  532.  
  533. /**********************************************************************
  534.  *                   Certs
  535.  **********************************************************************/
  536. SECItem *PK11_MakeIDFromPubKey(SECItem *pubKeyData);
  537. SECStatus PK11_TraverseSlotCerts(
  538.      SECStatus(* callback)(CERTCertificate*,SECItem *,void *),
  539.                                                 void *arg, void *wincx);
  540. CERTCertificate * PK11_FindCertFromNickname(char *nickname, void *wincx);
  541. CERTCertList * PK11_FindCertsFromNickname(char *nickname, void *wincx);
  542. CERTCertificate *PK11_GetCertFromPrivateKey(SECKEYPrivateKey *privKey);
  543. SECStatus PK11_ImportCert(PK11SlotInfo *slot, CERTCertificate *cert,
  544.                 CK_OBJECT_HANDLE key, char *nickname, PRBool includeTrust);
  545. SECStatus PK11_ImportDERCert(PK11SlotInfo *slot, SECItem *derCert,
  546.                 CK_OBJECT_HANDLE key, char *nickname, PRBool includeTrust);
  547. PK11SlotInfo *PK11_ImportCertForKey(CERTCertificate *cert, char *nickname,
  548.                                 void *wincx);
  549. PK11SlotInfo *PK11_ImportDERCertForKey(SECItem *derCert, char *nickname,
  550.                                 void *wincx);
  551. PK11SlotInfo *PK11_KeyForCertExists(CERTCertificate *cert,
  552.                     CK_OBJECT_HANDLE *keyPtr, void *wincx);
  553. PK11SlotInfo *PK11_KeyForDERCertExists(SECItem *derCert,
  554.                     CK_OBJECT_HANDLE *keyPtr, void *wincx);
  555. CERTCertificate * PK11_FindCertByIssuerAndSN(PK11SlotInfo **slot,
  556.                     CERTIssuerAndSN *sn, void *wincx);
  557. CERTCertificate * PK11_FindCertAndKeyByRecipientList(PK11SlotInfo **slot,
  558.     SEC_PKCS7RecipientInfo **array, SEC_PKCS7RecipientInfo **rip,
  559.                 SECKEYPrivateKey**privKey, void *wincx);
  560. int PK11_FindCertAndKeyByRecipientListNew(NSSCMSRecipient **recipientlist,
  561.                 void *wincx);
  562. SECStatus PK11_TraverseCertsForSubjectInSlot(CERTCertificate *cert,
  563.     PK11SlotInfo *slot, SECStatus(*callback)(CERTCertificate *, void *),
  564.     void *arg);
  565. CERTCertificate *PK11_FindCertFromDERCert(PK11SlotInfo *slot, 
  566.                       CERTCertificate *cert, void *wincx);
  567. SECStatus PK11_ImportCertForKeyToSlot(PK11SlotInfo *slot, CERTCertificate *cert,
  568.                     char *nickname, PRBool addUsage,
  569.                     void *wincx);
  570. CERTCertificate *PK11_FindBestKEAMatch(CERTCertificate *serverCert,void *wincx);
  571. PRBool PK11_FortezzaHasKEA(CERTCertificate *cert);
  572. CK_OBJECT_HANDLE PK11_FindCertInSlot(PK11SlotInfo *slot, CERTCertificate *cert,
  573.                      void *wincx);
  574. SECStatus PK11_TraverseCertsForNicknameInSlot(SECItem *nickname,
  575.     PK11SlotInfo *slot, SECStatus(*callback)(CERTCertificate *, void *),
  576.     void *arg);
  577. CERTCertList * PK11_ListCerts(PK11CertListType type, void *pwarg);
  578. CERTCertList * PK11_ListCertsInSlot(PK11SlotInfo *slot);
  579. CERTSignedCrl* PK11_ImportCRL(PK11SlotInfo * slot, SECItem *derCRL, char *url,
  580.     int type, void *wincx, PRInt32 importOptions, PRArenaPool* arena, PRInt32 decodeOptions);
  581.  
  582. /**********************************************************************
  583.  *                   Sign/Verify 
  584.  **********************************************************************/
  585. int PK11_SignatureLen(SECKEYPrivateKey *key);
  586. PK11SlotInfo * PK11_GetSlotFromPrivateKey(SECKEYPrivateKey *key);
  587. SECStatus PK11_Sign(SECKEYPrivateKey *key, SECItem *sig, SECItem *hash);
  588. SECStatus PK11_VerifyRecover(SECKEYPublicKey *key, SECItem *sig,
  589.                          SECItem *dsig, void * wincx);
  590. SECStatus PK11_Verify(SECKEYPublicKey *key, SECItem *sig, 
  591.                         SECItem *hash, void *wincx);
  592.  
  593.  
  594.  
  595. /**********************************************************************
  596.  *                   Crypto Contexts
  597.  **********************************************************************/
  598. void PK11_DestroyContext(PK11Context *context, PRBool freeit);
  599. PK11Context *PK11_CreateContextBySymKey(CK_MECHANISM_TYPE type,
  600.     CK_ATTRIBUTE_TYPE operation, PK11SymKey *symKey, SECItem *param);
  601. PK11Context *PK11_CreateDigestContext(SECOidTag hashAlg);
  602. PK11Context *PK11_CloneContext(PK11Context *old);
  603. SECStatus PK11_DigestBegin(PK11Context *cx);
  604. /*
  605.  * The output buffer 'out' must be big enough to hold the output of
  606.  * the hash algorithm 'hashAlg'.
  607.  */
  608. SECStatus PK11_HashBuf(SECOidTag hashAlg, unsigned char *out, unsigned char *in,
  609.                     int32 len);
  610. SECStatus PK11_DigestOp(PK11Context *context, const unsigned char *in, 
  611.                         unsigned len);
  612. SECStatus PK11_CipherOp(PK11Context *context, unsigned char * out, int *outlen, 
  613.                 int maxout, unsigned char *in, int inlen);
  614. SECStatus PK11_Finalize(PK11Context *context);
  615. SECStatus PK11_DigestFinal(PK11Context *context, unsigned char *data, 
  616.                 unsigned int *outLen, unsigned int length);
  617. SECStatus PK11_SaveContext(PK11Context *cx,unsigned char *save,
  618.                         int *len, int saveLength);
  619.  
  620. /* Save the context's state, with possible allocation.
  621.  * The caller may supply an already allocated buffer in preAllocBuf,
  622.  * with length pabLen.  If the buffer is large enough for the context's
  623.  * state, it will receive the state.
  624.  * If the buffer is not large enough (or NULL), then a new buffer will
  625.  * be allocated with PORT_Alloc.
  626.  * In either case, the state will be returned as a buffer, and the length
  627.  * of the state will be given in *stateLen.
  628.  */
  629. unsigned char *
  630. PK11_SaveContextAlloc(PK11Context *cx,
  631.                       unsigned char *preAllocBuf, unsigned int pabLen,
  632.                       unsigned int *stateLen);
  633.  
  634. SECStatus PK11_RestoreContext(PK11Context *cx,unsigned char *save,int len);
  635. SECStatus PK11_GenerateFortezzaIV(PK11SymKey *symKey,unsigned char *iv,int len);
  636. void PK11_SetFortezzaHack(PK11SymKey *symKey) ;
  637.  
  638.  
  639. /**********************************************************************
  640.  *                   PBE functions 
  641.  **********************************************************************/
  642.  
  643. /* This function creates PBE parameters from the given inputs.  The result
  644.  * can be used to create a password integrity key for PKCS#12, by sending
  645.  * the return value to PK11_KeyGen along with the appropriate mechanism.
  646.  */
  647. SECItem * 
  648. PK11_CreatePBEParams(SECItem *salt, SECItem *pwd, unsigned int iterations);
  649.  
  650. /* free params created above (can be called after keygen is done */
  651. void PK11_DestroyPBEParams(SECItem *params);
  652.  
  653. SECAlgorithmID *
  654. PK11_CreatePBEAlgorithmID(SECOidTag algorithm, int iteration, SECItem *salt);
  655. PK11SymKey *
  656. PK11_PBEKeyGen(PK11SlotInfo *slot, SECAlgorithmID *algid,  SECItem *pwitem,
  657.            PRBool faulty3DES, void *wincx);
  658. PK11SymKey *
  659. PK11_RawPBEKeyGen(PK11SlotInfo *slot, CK_MECHANISM_TYPE type, SECItem *params,
  660.         SECItem *pwitem, PRBool faulty3DES, void *wincx);
  661. SECItem *
  662. PK11_GetPBEIV(SECAlgorithmID *algid, SECItem *pwitem);
  663.  
  664. /**********************************************************************
  665.  * Functions to manage secmod flags
  666.  **********************************************************************/
  667. PK11DefaultArrayEntry * PK11_GetDefaultArray(int *);
  668. SECStatus PK11_UpdateSlotAttribute(PK11SlotInfo *, PK11DefaultArrayEntry *,
  669.                             PRBool );
  670.  
  671. /**********************************************************************
  672.  * Functions to look at PKCS #11 dependent data
  673.  **********************************************************************/
  674. PK11GenericObject *PK11_FindGenericObjects(PK11SlotInfo *slot, 
  675.                         CK_OBJECT_CLASS objClass);
  676. PK11GenericObject *PK11_GetNextGenericObject(PK11GenericObject *object);
  677. PK11GenericObject *PK11_GetPrevGenericObject(PK11GenericObject *object);
  678. SECStatus PK11_UnlinkGenericObject(PK11GenericObject *object);
  679. SECStatus PK11_LinkGenericObject(PK11GenericObject *list,
  680.                  PK11GenericObject *object);
  681. SECStatus PK11_DestroyGenericObjects(PK11GenericObject *object);
  682. SECStatus PK11_DestroyGenericObject(PK11GenericObject *object);
  683. SECStatus PK11_ReadRawAttribute(PK11ObjectType type, void *object, 
  684.                 CK_ATTRIBUTE_TYPE attr, SECItem *item);
  685.  
  686.  
  687. /**********************************************************************
  688.  * New fucntions which are already depricated....
  689.  **********************************************************************/
  690. SECItem *
  691. PK11_GetLowLevelKeyIDForCert(PK11SlotInfo *slot,
  692.                     CERTCertificate *cert, void *pwarg);
  693. SECItem *
  694. PK11_GetLowLevelKeyIDForPrivateKey(SECKEYPrivateKey *key);
  695.  
  696. PRBool SECMOD_HasRootCerts(void);
  697.  
  698. SEC_END_PROTOS
  699.  
  700. #endif
  701.